// 导入封装的请求工具
import http from '../../../utils/https.js';

Page({
  /**
   * 页面的初始数据
   */
  data: {
    userInfo: {},
    relationToOwner: '',
    showEditModal: false, // 是否显示修改弹窗
    showDebug: false, // 是否显示调试信息
    editForm: {
      residentName: '',
      idNumber: '',
      phoneNumber: '',
      wechatId: '',
      relationToOwnerId: '',
      relationToOwnerIndex: 0,
      selectedRelationName: ''
    },
    ownerRelations: [], // 与业主的关系列表
    avatarUrl: '/images/default-avatar.png', // 头像URL
    auditStatus: 1, // 审核状态：0审核成功，1审核中，2审核失败
    auditStatusText: '审核中', // 审核状态文本
    auditStatusClass: 'audit-pending' // 审核状态样式类
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    this.loadUserInfo();
    this.getOwnerRelations(); // 获取与业主的关系列表
  },

  /**
   * 加载用户信息
   */
  loadUserInfo() {
    try {
      // 从本地存储获取用户信息
      const userInfo = wx.getStorageSync('userInfo');
      console.log('从本地存储获取的用户信息:', userInfo);

      if (userInfo && userInfo.userId) {
        // 获取全局应用实例
        const app = getApp();
        // 从全局变量获取用户信息（如果有）
        const globalUserInfo = app.globalData.userInfo;

        // 合并本地和全局用户信息
        const finalUserInfo = { ...userInfo, ...globalUserInfo };

        this.setData({
          userInfo: finalUserInfo
        });

        // 调用接口获取详细住户信息
        this.getResidentInfo(finalUserInfo.userId);
      } else {
        // 未找到用户信息，跳转到登录页
        wx.showToast({
          title: '请先登录',
          icon: 'error',
          success: () => {
            wx.navigateTo({
              url: '/pages/login/login'
            });
          }
        });
      }
    } catch (error) {
      console.error('加载用户信息出错:', error);
      wx.showToast({
        title: '加载用户信息失败',
        icon: 'error'
      });
    }
  },

  /**
   * 获取住户详细信息
   */
  getResidentInfo(userId) {
    wx.showLoading({
      title: '加载中...'
    });

    // 使用全局baseUrl
    const app = getApp();
    const baseUrl = app.globalData.baseUrl || 'http://localhost:8080';

    wx.request({
      url: `${baseUrl}/resident/resident/userId/${userId}`,
      method: 'GET',
      header: {
        'Authorization': 'Bearer ' + wx.getStorageSync('token')
      },
      success: (res) => {
        wx.hideLoading();
        console.log('获取住户信息响应:', res.data);

        if (res.data && res.data.code === 200 && res.data.data) {
          // 假设返回的是数组，取第一个元素
          const residentInfo = Array.isArray(res.data.data) ? res.data.data[0] : res.data.data;

          // 处理与业主关系的显示
          const relationMap = {
            '1': '本人',
            '2': '配偶',
            '3': '子女',
            '4': '父母',
            '5': '其他'
          };
          const relationToOwner = relationMap[residentInfo.relationToOwnerId] || '未知';

          // 处理审核状态
          let auditStatusText = '审核中';
          let auditStatusClass = 'audit-unknown';
          if (residentInfo.auditStatus === 0) {
            auditStatusText = '审核成功';
            auditStatusClass = 'audit-success';
          } else if (residentInfo.auditStatus === 2) {
            auditStatusText = '审核失败';
            auditStatusClass = 'audit-failed';
          }

          // 构建适配WXML的数据对象
          const userInfo = {
            id: residentInfo.id,
            resident_name: residentInfo.residentName,
            id_number: residentInfo.idNumber,
            phone_number: residentInfo.phoneNumber,
            wechat_id: residentInfo.wechatId
          };

          // 设置编辑表单的初始值
          this.setData({
            userInfo: userInfo,
            relationToOwner: relationToOwner,
            'editForm.residentName': residentInfo.residentName || '',
            'editForm.idNumber': residentInfo.idNumber || '',
            'editForm.phoneNumber': residentInfo.phoneNumber || '',
            'editForm.wechatId': residentInfo.wechatId || '',
            'editForm.relationToOwnerId': residentInfo.relationToOwnerId || '',
            'editForm.selectedRelationName': relationToOwner,
            avatarUrl: residentInfo.avatarUrl || '/images/default-avatar.png',
            auditStatus: residentInfo.auditStatus || 1,
            auditStatusText: auditStatusText,
            auditStatusClass: auditStatusClass
          });

          // 如果已有业主关系列表，设置选中索引
          if (this.data.ownerRelations.length > 0 && residentInfo.relationToOwnerId) {
            const index = this.data.ownerRelations.findIndex(item => item.id === residentInfo.relationToOwnerId);
            if (index !== -1) {
              this.setData({
                'editForm.relationToOwnerIndex': index
              });
            }
          }
        } else {
          wx.showToast({
            title: '获取住户信息失败',
            icon: 'error'
          });
        }
      },
      fail: (err) => {
        wx.hideLoading();
        console.error('获取住户信息失败:', err);
        wx.showToast({
          title: '网络异常，请重试',
          icon: 'error'
        });
      }
    });
  },

  /**
   * 获取与业主的关系列表
   */
  getOwnerRelations: function() {
    wx.showLoading({
      title: '加载中...'
    });
    try {
      http.get('ownerRelation/ownerRelation/list')
        .then(res => {
          wx.hideLoading();
          console.log('获取与业主的关系列表响应:', res);
          if (res && res.code === 200) {
            this.setData({
              ownerRelations: res.rows || []
            });
            // 如果已有选中的关系，设置索引
            if (this.data.editForm.relationToOwnerId) {
              const index = res.rows.findIndex(item => item.id === this.data.editForm.relationToOwnerId);
              if (index !== -1) {
                this.setData({
                  'editForm.relationToOwnerIndex': index,
                  'editForm.selectedRelationName': res.rows[index].relationName
                });
              }
            }
          } else {
            wx.showToast({
              title: res.msg || '获取数据失败',
              icon: 'error'
            });
          }
        })
        .catch(err => {
          wx.hideLoading();
          console.error('获取与业主的关系列表失败:', err);
          wx.showToast({
            title: '网络异常，请重试',
            icon: 'error'
          });
        });
    } catch (error) {
      wx.hideLoading();
      console.error('获取关系列表异常:', error);
      wx.showToast({
        title: '系统异常，请重试',
        icon: 'error'
      });
    }
  },

  /**
   * 与业主关系选择改变事件
   */
  relationChange: function(e) {
    const index = e.detail.value;
    const relation = this.data.ownerRelations[index] || {};
    this.setData({
      'editForm.relationToOwnerIndex': index,
      'editForm.relationToOwnerId': relation.id || '',
      'editForm.selectedRelationName': relation.relationName || ''
    });
  },

  /**
   * 显示修改弹窗
   */
  showEditModal: function() {
    // 确保编辑表单数据与当前显示数据一致
    this.setData({
      'editForm.residentName': this.data.userInfo.resident_name || '',
      'editForm.idNumber': this.data.userInfo.id_number || '',
      'editForm.phoneNumber': this.data.userInfo.phone_number || '',
      'editForm.wechatId': this.data.userInfo.wechat_id || '',
      'editForm.relationToOwnerId': this.data.editForm.relationToOwnerId || '',
      'editForm.selectedRelationName': this.data.relationToOwner || '',
      showEditModal: true,
      showDebug: true // 显示调试信息
    });
    
    console.log('弹窗数据初始化:', this.data.editForm);
  },

  /**
   * 隐藏修改弹窗
   */
  hideEditModal: function() {
    this.setData({
      showEditModal: false,
      showDebug: false
    });
  },

  /**
   * 处理输入框变化
   */
  onInputChange: function(e) {
    const field = e.currentTarget.dataset.field;
    const value = e.detail.value;
    
    this.setData({
      [`editForm.${field}`]: value
    });
    
    console.log(`字段 ${field} 更新为:`, value);
  },

  /**
   * 更换头像
   */
  changeAvatar: function() {
    wx.showActionSheet({
      itemList: ['拍照', '从相册选择'],
      success: (res) => {
        if (res.tapIndex === 0) {
          // 拍照
          this.chooseImage('camera');
        } else if (res.tapIndex === 1) {
          // 从相册选择
          this.chooseImage('album');
        }
      }
    });
  },

  /**
   * 选择图片
   */
  chooseImage: function(sourceType) {
    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: [sourceType],
      success: (res) => {
        const tempFilePath = res.tempFilePaths[0];
        
        // 预览图片
        wx.previewImage({
          urls: [tempFilePath],
          current: tempFilePath
        });

        // 询问是否使用该图片作为头像
        wx.showModal({
          title: '确认头像',
          content: '是否使用这张图片作为头像？',
          success: (modalRes) => {
            if (modalRes.confirm) {
              this.uploadAvatar(tempFilePath);
            }
          }
        });
      },
      fail: (err) => {
        console.error('选择图片失败:', err);
        wx.showToast({
          title: '选择图片失败',
          icon: 'error'
        });
      }
    });
  },

  /**
   * 上传头像
   */
  uploadAvatar: function(filePath) {
    wx.showLoading({
      title: '上传中...'
    });

    // 这里可以调用上传接口，暂时先更新本地显示
    // 实际项目中需要调用后端接口上传图片
    this.setData({
      avatarUrl: filePath
    });

    wx.hideLoading();
    wx.showToast({
      title: '头像更新成功',
      icon: 'success'
    });

    // TODO: 调用后端接口上传头像
    // this.uploadToServer(filePath);
  },

  /**
   * 提交修改表单
   */
  submitEditForm: function() {
    const { residentName, idNumber, phoneNumber, wechatId, relationToOwnerId } = this.data.editForm;

    console.log('提交的表单数据:', this.data.editForm);

    // 简单验证
    if (!residentName || residentName.trim() === '') {
      wx.showToast({
        title: '请输入住户姓名',
        icon: 'error'
      });
      return;
    }

    if (!idNumber || idNumber.trim() === '') {
      wx.showToast({
        title: '请输入证件号码',
        icon: 'error'
      });
      return;
    }

    if (!phoneNumber || phoneNumber.trim() === '') {
      wx.showToast({
        title: '请输入手机号码',
        icon: 'error'
      });
      return;
    }

    wx.showLoading({
      title: '提交中...'
    });

    // 构建请求数据 - 使用与后端SQL字段名完全匹配的字段名
    const data = {
      id: this.data.userInfo.id,
      residentName: residentName.trim(),
      idNumber: idNumber.trim(),
      phoneNumber: phoneNumber.trim(),
      wechatId: wechatId ? wechatId.trim() : '',
      relationToOwnerId: relationToOwnerId || null,
      auditStatus: 1
    };

    console.log('发送到后端的数据:', data);

    try {
      // 使用封装的http工具
      http.put('resident/resident/', data)
        .then(res => {
          wx.hideLoading();
          console.log('修改住户信息响应:', res);

          if (res && res.code === 200) {
            wx.showToast({
              title: '修改成功',
              icon: 'success',
              success: () => {
                this.hideEditModal();
                // 重新加载用户信息
                this.loadUserInfo();
              }
            });
          } else {
            wx.showToast({
              title: res.msg || '修改失败',
              icon: 'error'
            });
          }
        })
        .catch(err => {
          wx.hideLoading();
          console.error('修改住户信息失败:', err);
          wx.showToast({
            title: '网络异常，请重试',
            icon: 'error'
          });
        });
    } catch (error) {
      wx.hideLoading();
      console.error('提交表单异常:', error);
      wx.showToast({
        title: '系统异常，请重试',
        icon: 'error'
      });
    }
  },

  /**
   * 退出登录
   */
  handleExit() {
    wx.showModal({
      title: '提示',
      content: '确定要退出登录吗？',
      success: (res) => {
        if (res.confirm) {
          // 清除本地存储的token和用户信息
          wx.removeStorageSync('token');
          wx.removeStorageSync('userInfo');

          // 清除全局变量
          const app = getApp();
          app.globalData.token = null;
          app.globalData.userInfo = null;

          // 跳转到登录页，使用reLaunch关闭所有页面
          wx.reLaunch({
            url: '/pages/login/login'
          });
        }
      }
    });
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 每次显示页面时刷新数据
    this.loadUserInfo();
  }
});